package com.epcs.controller.action;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts2.dispatcher.SessionMap;
import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.struts2.interceptor.SessionAware;

import com.epcs.model.bo.CommentBO;
import com.epcs.model.bo.EventBO;
import com.epcs.model.bo.EventcategoryBO;
import com.epcs.model.bo.FollowingBO;
import com.epcs.model.bo.NotificationBO;
import com.epcs.model.bo.UserBO;
import com.epcs.model.dao.EventDAO;
import com.epcs.model.dao.FollowingDAO;
import com.epcs.model.dto.Account;
import com.epcs.model.dto.Comment;
import com.epcs.model.dto.Event;
import com.epcs.model.dto.Eventcategory;
import com.epcs.model.dto.Following;
import com.epcs.model.dto.Notification;
import com.epcs.util.EmailValidator;
import com.epcs.util.EpcsDateTimeUtil;
import com.epcs.util.MailHandler;
import com.opensymphony.xwork2.ActionSupport;

public class ManageEventAction extends ActionSupport implements SessionAware, ServletRequestAware {

	// ---------- input fields ----------//
	private SessionMap<String, Object> sessionMap;
	private HttpServletRequest request;

	private String id;
	private String title;
	private Integer reminder;
	private String isAllDay;
	private String daterange_start;
	private String daterange_end;
	private Integer eventCat;
	private String location;
	private String description;
	private String invitedPerson;
	private String visibility;
	private String[] invitedPersonArr;
	private String invitedUsername;
	private String notificationId;
	private int pageNumber;
	private String reminder_now;

	
	// -----------------------------------------------------DUY---------------------------------
	private String categoryID;

	// -----------------------------------------------------------------------------------------

	// ----------Action method -----------//

	// Tao Event
	public String createEvent() {
		Account account = (Account) sessionMap.get("USER_INFO");
		if(account != null){
		
		EmailValidator emailValidator = new EmailValidator();
		FollowingBO followingBO = new FollowingBO();
		String currentTime = EpcsDateTimeUtil.getCurrentIsoDateTime();
		Event newEvent = new Event();
		newEvent.setReminderTime(reminder);
		newEvent.setAccount(account);
		newEvent.setTitle(title);
		newEvent.setStartTime(daterange_start);

		if (isAllDay != null) {
			newEvent.setIsAllDayEvent(true);
			String newEndDay = EpcsDateTimeUtil.getNextDayISO(daterange_end);
			newEvent.setEndTime(newEndDay);

		} else {
			newEvent.setIsAllDayEvent(false);
			newEvent.setEndTime(daterange_end);
		}
		newEvent.setIsRecurrent(false);
		// Add category vao Event
		// Lay category dua vao id cua category truyen vao
		EventcategoryBO newCatBO = new EventcategoryBO();
		Eventcategory newCat = null;
		if (eventCat != null){
			if (!eventCat.equals("")){
				newCat = newCatBO.getCatByID(eventCat);
			}
		}
		newEvent.setEventcategory(newCat);
		newEvent.setLocation(location);
		newEvent.setDescription(description);
		newEvent.setStatus("confirmed");
		newEvent.setDirty(false);
		newEvent.setSequence(0);
		newEvent.setUpdated(EpcsDateTimeUtil.getCurrentIsoDateTime());
		newEvent.setVisibility(visibility);
		
		if("on".equals(reminder_now)){
			newEvent.setIsNotified(true);
		}else {
			newEvent.setIsNotified(false);
		}

		// -----------------------------------//
		// ---------------Tạo Event-----------//
		EventBO newEventBO = new EventBO();
		// Trả về id của event mới
		int newEventId = newEventBO.createEvent(newEvent);
		

		// Add ng tao va new event id vao following
		Following newFollow = new Following();
		newFollow.setAccount(account);
		newFollow.setIdOfFollow(newEventId);
		newFollow.setTypeOfFollow("event");

		// khoi tao 1 eventBO
		EventBO newFollowBO = new EventBO();
		// Goi ham createFollow trong eventBO
		newFollowBO.createFollow(newFollow);

		// -----------------------------------//
		// ----------------Add nguoi duoc invite vao bang follow, dong thoi tao event cho nguoi dc
		// invite --------------//
		// Tach chuoi nguoi dc invite
		String[] arrInvitedPerson = invitedPerson.split(",");
	
		for (int i = 0; i < arrInvitedPerson.length; i++) {
			String username = arrInvitedPerson[i];
			if(!account.getUsername().equals(username)){
				// Kiem account co username do
				UserBO newUserBO = new UserBO();
				Account newAccount = newUserBO.getAccountByUsername(username);
				// Add 1 follow moi
				if (newAccount != null) {
					// Add 1 Event mới cho User , với organizer = nguoi tao Event do, va OriginalEventId
					// = id cua event dc moi
					Event eventInvited = new Event();
					EventBO eventInvitedBO = new EventBO();
					Following checkExitFollowing = followingBO.loadFollowingEvent(newAccount, id);
					
					// kiem tra xem username da follow chua
					
						if(checkExitFollowing == null){
							eventInvited = eventInvitedBO.getEvent(Integer.toString(newEventId));
							// Lấy eventId vừa tạo ra, event này là clone của event chính, trong đó orginalId là
							// id của event chính và organizer là người sở hữu
							//Kiểm tra xem có phải thông báo gấp hay không
							if("on".equals(reminder_now)){
								createEventForInvite(newAccount, eventInvited, account.getUsername(),true);
								// Thiết lập thuộc tính cho following
								Following newFollow2 = new Following();
								newFollow2.setAccount(newAccount);
								newFollow2.setIdOfFollow(newEventId);
								newFollow2.setTypeOfFollow("event");
								
								

								// Tạo following mới cho account được mời
								newFollowBO.createFollow(newFollow2);

								// ---------------------------NHÂN-----------------------------------------------------------------
							
								NotificationBO notifyBo = new NotificationBO();
								

								
								
								//tạo mới notification info_invited
								Notification notificationInfo = new Notification();
								notificationInfo.setFollowing(newFollow2);
								notificationInfo.setContent("Bạn đã được mời tham gia một sự kiện. Diễn ra trong "+reminder+" phút nữa.");
								notificationInfo.setStatus(0);
								notificationInfo.setTypeOfNotification("timmer");
								notificationInfo.setLastUpdated(currentTime);
								notifyBo.insertNotification(notificationInfo);
								
								// ----------------------------------------------------------------------------------
							}else {
								createEventForInvite(newAccount, eventInvited, account.getUsername(),false);
								// Thiết lập thuộc tính cho following
								Following newFollow2 = new Following();
								newFollow2.setAccount(newAccount);
								newFollow2.setIdOfFollow(newEventId);
								newFollow2.setTypeOfFollow("event");
								
								// Tạo following mới cho account được mời
								newFollowBO.createFollow(newFollow2);

								// ---------------------------NHÂN-----------------------------------------------------------------
								String date;
										String inpStartTime = newEvent.getStartTime();
										if(newEvent.getIsAllDayEvent()){
											 date ="Diễn ra vào " +EpcsDateTimeUtil.convertDateTimeWithPattern(inpStartTime,"'ngày' dd-MM-yyyy");
										}else{
											 date = "Diễn ra vào lúc " + EpcsDateTimeUtil.convertDateTimeWithPattern(inpStartTime, "HH'h' mm,'ngày' dd-MM-yyyy");
										}
										
								
						
								NotificationBO notifyBo = new NotificationBO();
							
								//tạo mới notification info_invited
								Notification notificationInfo = new Notification();
								notificationInfo.setFollowing(newFollow2);
								
								notificationInfo.setContent("Bạn đã được mời tham gia một sự kiện. "+date);
								notificationInfo.setStatus(0);
								notificationInfo.setTypeOfNotification("info");
								notificationInfo.setLastUpdated(currentTime);
								notifyBo.insertNotification(notificationInfo);
								
								// ----------------------------------------------------------------------------------
							}
						}	
				}else if(emailValidator.validate(username)){
					String startTime;
					String endTime;
					if(newEvent.getIsAllDayEvent() == true){
						startTime =EpcsDateTimeUtil.convertDateTimeWithPattern(newEvent.getStartTime(), "'Sáng, ngày' dd-MM-yyyy");
						endTime   =EpcsDateTimeUtil.convertDateTimeWithPattern(newEvent.getEndTime(), "'Chiều, ngày' dd-MM-yyyy");
					}else {
						startTime =EpcsDateTimeUtil.convertDateTimeWithPattern(newEvent.getStartTime(), "HH'h'mm 'ngày' dd-MM-yyyy");
						endTime   =EpcsDateTimeUtil.convertDateTimeWithPattern(newEvent.getEndTime(), "HH'h'mm 'ngày' dd-MM-yyyy");
					}
					MailHandler mail = new MailHandler();
					String content = "<h2>Thông tin chi tiết:</h2> <p></p> " 
							+ "Tên sự kiện: " + newEvent.getTitle() + " <br/>"
							+ "Người mời: " + newEvent.getAccount().getFullname() +" <br/> "
							+ "Email người mời: "+ newEvent.getAccount().getUsername()+"<br/>"
							+ "Thời gian: Từ " + startTime +" đến " + endTime +" <br/> " 
							+ "Địa điểm: " + newEvent.getLocation()
							+ " <br/> <br/> Mail này được gửi từ hệ thống Đồng bộ lịch và sự kiện . Tham gia cùng bạn bè <a href='http://epcs.com:8080/EPCS'>EPCS</a>";
				
							String title = "Bạn đã được mời tham gia một sự kiên.";
					mail.sendEMail(username,content,title);
					Thread thread = new Thread(mail);
					thread.start();
					System.out.println("Verified Mail has been sent!");
				}
			}
			
		}		
	
	
			if (newEventId != 0) {
				return "Success";
			} else {
				return "Fail";
			}
		}else
		{
			return "Unauthorized";
		}
	}

	public Integer createEventForInvite(Account accountInvite, Event originalEvent, String organizer,boolean isReminderNow) {

		Event newEvent = new Event();
		EpcsDateTimeUtil dateUtil = new EpcsDateTimeUtil();
		String currentTime = dateUtil.getCurrentIsoDateTime();
		newEvent.setReminderTime(reminder);
		newEvent.setAccount(accountInvite);
		newEvent.setTitle(title);
		if (isAllDay != null) {
			newEvent.setIsAllDayEvent(true);
			String newEndDay = dateUtil.getNextDayISO(daterange_end);
			
			newEvent.setEndTime(newEndDay);
		} else {
			newEvent.setIsAllDayEvent(false);
			newEvent.setEndTime(daterange_end);
		}
		newEvent.setIsRecurrent(false);
		newEvent.setStartTime(daterange_start);
		// Add category vao Event
		// Lay category dua vao id cua category truyen vao
		EventcategoryBO newCatBO = new EventcategoryBO();
		Eventcategory newCat = null;
		if (eventCat != null){
			if (!eventCat.equals("")){
				newCat = newCatBO.getCatByID(eventCat);
			}
		}
		newEvent.setEventcategory(newCat);
		newEvent.setLocation(location);
		newEvent.setDescription(description);
		newEvent.setStatus("confirmed");
		newEvent.setDirty(false);
		newEvent.setSequence(0);
		newEvent.setUpdated(EpcsDateTimeUtil.getCurrentIsoDateTime());
		newEvent.setVisibility("private");
		newEvent.setOrganizer(organizer);
		newEvent.setOriginalEvent(originalEvent);
		newEvent.setIsNotified(isReminderNow);

		// -----------------------------------//
		// ---------------Tạo Event-----------//c
		EventBO newEventBO = new EventBO();
		// Trả về id của event mới
		int newEventId = newEventBO.createEvent(newEvent);

		return newEventId;
	}

	// Update Event
	public String updateEvent() {
		Account account = (Account) sessionMap.get("USER_INFO");
		
		EmailValidator emailValidator = new EmailValidator();
		String currentTime = EpcsDateTimeUtil.getCurrentIsoDateTime();
		EventBO newEventBO = new EventBO();
		FollowingDAO followDAO =  new FollowingDAO();
		NotificationBO notificationBO = new NotificationBO();
		EventDAO eventDAO = new EventDAO();
		Event eventDetail = newEventBO.getEvent(id);
		/** Nhân
		 *  tạo sẵn nội dung của sự kiên
		 */
		String notificationContent = "Sự kiện bạn đang theo dõi đã được thay đổi";
		boolean checkChange = false;
		if(!eventDetail.getTitle().equals(title)){
			checkChange = true;
				notificationContent += " tiêu đề,";
			} 
		
		if(eventDetail.getLocation() != null){
			if(!eventDetail.getLocation().equals(location)){
				checkChange = true;
				notificationContent += " địa điểm,";
			} 
		} else if(location!=null){
			if(!location.equals(eventDetail.getLocation())){
				checkChange = true;
				notificationContent += " địa điểm,";
			} 
		}
		if(eventDetail.getDescription()!=null){
			if (!eventDetail.getDescription().equals(description)){
				checkChange = true;
				notificationContent += " nội dung,";
			} 
		}else if(description!=null){
			if (!description.equals(eventDetail.getDescription())){
				checkChange = true;
				notificationContent += " nội dung,";
			} 
		}
		
		long oldStartTime = EpcsDateTimeUtil.getMillisecondsByString(eventDetail.getStartTime());
		long oldEndTime = EpcsDateTimeUtil.getMillisecondsByString(eventDetail.getEndTime());
		long newStartTime = EpcsDateTimeUtil.getMillisecondsByString(daterange_start);
		long newEndTime = EpcsDateTimeUtil.getMillisecondsByString(daterange_end);
		
		if(oldStartTime != newStartTime || oldEndTime != newEndTime ){
			checkChange = true;
			notificationContent += " thời gian,";
		}
		//----------------------------------------------------------------------------------
		eventDetail.setTitle(title);
		if (isAllDay != null) {
			eventDetail.setIsAllDayEvent(true);
		} else {
			eventDetail.setIsAllDayEvent(false);
		}
		eventDetail.setStartTime(daterange_start);
		eventDetail.setEndTime(daterange_end);
		eventDetail.setLocation(location);
		eventDetail.setDescription(description);
		eventDetail.setReminderTime(reminder);
		EventcategoryBO newCatBO = new EventcategoryBO();
		Eventcategory newCat = null;
		if (eventCat != null){
			if (!eventCat.equals("")){
				newCat = newCatBO.getCatByID(eventCat);
			}
		}
		eventDetail.setEventcategory(newCat);
		Integer curentSequence = eventDetail.getSequence();
		eventDetail.setSequence(curentSequence + 1);
		eventDetail.setUpdated(EpcsDateTimeUtil.getCurrentIsoDateTime());
		eventDetail.setVisibility(visibility);
		eventDetail.setDirty(true);
		boolean isNotified =  eventDetail.getIsNotified();
		eventDetail.setIsNotified(isNotified);

		newEventBO.updateEvent(eventDetail);
		// nếu kiểm tra là có thay đổi thì tạo notification cho các ng đã follow
		if(checkChange == true){
			// lấy list following của event
			List<Following> followingList = followDAO.getFollowingByEventID(eventDetail.getEventId());
			if(followingList != null){
				// kiểm tra xem có phải sự kiên chính k, nếu là event chính thì mới thực thi tiếp
				if(eventDetail.getOriginalEvent() ==  null){
					List<Integer> followingIdList = new ArrayList<Integer>();
					 
					for(int i = 0 ; i < followingList.size(); i ++){
						followingIdList.add(followingList.get(i).getFollowingId());
					}
					Account eventCreater = eventDetail.getAccount();
					
					//Lấy list follow event cần xóa, nhưng trừ creater ra. Bởi vỉ k cần tạo notification cho chính ng tạo
					List<Following> followingListExceptCreater = followDAO.getFollowingList(followingIdList,eventCreater);
					
					//Duyệt list followinng để tạo notification cho những ng đang theo dõi
					if(followingListExceptCreater != null){
						for(int i = 0 ; i < followingListExceptCreater.size(); i ++){
							Notification notificationUpdateInfo = new Notification();
							notificationUpdateInfo.setFollowing(followingListExceptCreater.get(i));
							notificationContent = notificationContent.substring(0, notificationContent.length()-1) + ".";
							notificationUpdateInfo.setContent(notificationContent);
							notificationUpdateInfo.setStatus(0);
							notificationUpdateInfo.setTypeOfNotification("info");
							notificationUpdateInfo.setLastUpdated(currentTime);
							notificationBO.insertNotification(notificationUpdateInfo);
						}
					}
				}
			}

		}
		
		/**
		 * Duyệt list event clone
		 * nếu trạng thái = confirmed, set lại tất cả thông tin
		 */
		List<Event> subEventList = eventDAO.getSubEventFromDB(eventDetail);
		for(int i = 0 ; i < subEventList.size(); i ++){
			Event subEventItem = subEventList.get(i);
			if("confirmed".equals(subEventList.get(i).getStatus())){
				subEventItem.setStartTime(eventDetail.getStartTime());
				subEventItem.setEndTime(eventDetail.getEndTime());
				subEventItem.setLocation(eventDetail.getLocation());
				subEventItem.setDescription(eventDetail.getDescription());
				subEventItem.setReminderTime(eventDetail.getReminderTime());
				subEventItem.setEventcategory(eventDetail.getEventcategory());
				subEventItem.setSequence(subEventItem.getSequence() + 1);
				subEventItem.setUpdated(eventDetail.getUpdated());
				subEventItem.setVisibility(eventDetail.getVisibility());
				subEventItem.setDirty(true);
				subEventItem.setTitle(eventDetail.getTitle());
				subEventItem.setIsAllDayEvent(eventDetail.getIsAllDayEvent());
				eventDAO.updateEvent(subEventItem);
			}
		}
		
		// -----------------------------------//
		// ----------------Add nguoi duoc invite vao bang follow, dong thoi tao event cho nguoi dc
		// invite --------------//
		// Tach chuoi nguoi dc invite
		String[] arrInvitedPerson = invitedPerson.split(",");
		for (int i = 0; i < arrInvitedPerson.length; i++) {
			String username = arrInvitedPerson[i];
			// Kiem account co username do
			if(!account.getUsername().equals(username)){
				UserBO newUserBO = new UserBO();
				FollowingBO followingBO = new FollowingBO();
				Account newAccount = newUserBO.getAccountByUsername(username);
				// Add 1 follow moi
				if (newAccount != null) {
					// Add 1 Event mới cho User , với organizer = nguoi tao Event do, va OriginalEventId
					// = id cua event dc moi
					Event eventInvited = new Event();
					EventBO eventInvitedBO = new EventBO();
					Following checkExitFollowing = followingBO.loadFollowingEvent(newAccount, id);
					
					// kiem tra xem username da follow chua
					if(checkExitFollowing == null){
						eventInvited = eventInvitedBO.getEvent(Integer.toString(Integer.parseInt(id)));
						// Lấy eventId vừa tạo ra, event này là clone của event chính, trong đó orginalId là
						// id của event chính và organizer là người sở hữu
						
						int eventOfFolllowId = createEventForInvite(newAccount, eventInvited, account.getUsername(),false);
						// Tạo follow cho event clone mới tạo
						Following newFollow2 = new Following();
						// account là người đc mời
						newFollow2.setAccount(newAccount);
						// id của event clone mới tạo
						newFollow2.setIdOfFollow(Integer.parseInt(id));
						newFollow2.setTypeOfFollow("event");

						// khoi tao 1 eventBO
						EventBO newFollowBO2 = new EventBO();
						// Goi ham createFollow trong eventBO
						newFollowBO2.createFollow(newFollow2);
						// ---------------------------NHÂN-----------------------------------------------------------------
						
						NotificationBO notifyBo = new NotificationBO();
						
						//tạo mới notification info_invited
						Notification notificationInfo = new Notification();
						notificationInfo.setFollowing(newFollow2);
						notificationInfo.setContent("Bạn đã được mời tham gia một sự kiện.");
						notificationInfo.setStatus(0);
						notificationInfo.setTypeOfNotification("info");
						notificationInfo.setLastUpdated(currentTime);
						notifyBo.insertNotification(notificationInfo);
						
						// ---------------------------------------------------------------------------------
					}
					
				}else if (emailValidator.validate(username)){
					String startTime;
					String endTime;
					if(eventDetail.getIsAllDayEvent() == true){
						startTime =EpcsDateTimeUtil.convertDateTimeWithPattern(eventDetail.getStartTime(), "'Sáng, ngày' dd-MM-yyy");
						endTime   =EpcsDateTimeUtil.convertDateTimeWithPattern(eventDetail.getEndTime(), "'Chiều, ngày' dd-MM-yyy");
					}else{
						startTime =EpcsDateTimeUtil.convertDateTimeWithPattern(eventDetail.getStartTime(), "HH'h'mm 'ngày' dd-MM-yyyy");
						endTime   =EpcsDateTimeUtil.convertDateTimeWithPattern(eventDetail.getEndTime(), "HH'h'mm 'ngày' dd-MM-yyyy");
					}
					
					MailHandler mail = new MailHandler();
					String content = "<h2>Thông tin chi tiết:</h2>" 
							+ "Tên sự kiện: " + eventDetail.getTitle() + " <br/>"
							+ "Người mời: " + eventDetail.getAccount().getFullname() +" <br/> "
							+ "Email người mời: " +eventDetail.getAccount().getUsername()+"<br/>"
							+ "Thời gian: Từ " +startTime + " đến " + endTime +" <br/> " 
							+ "Địa điểm: " + eventDetail.getLocation() 
							+ " <br/> Mail này được gửi từ hệ thống Đồng bộ lịch và sự kiện . Tham gia cùng bạn bè <a href='http://epcs.com:8080/EPCS'>EPCS</a>";
				
					String title = "Bạn đã được mời tham gia một sự kiên.";
					mail.sendEMail(username,content,title);
					Thread thread = new Thread(mail);
					thread.start();
					System.out.println("Verified Mail has been sent!");
				}
			}
		}
		
		request.setAttribute("SUCCESS_MESSAGE", "Đã cập nhật!");
		return "Success";
	}


	// Refomfirm Event
	public String reConfirmlEvent() {

		EventBO newEventBO = new EventBO();
		// Lấy event dựa trên id truyền vào
		Event eventDetail = newEventBO.getEvent(id);
		// Set lại trạng thái thành cancel
		eventDetail.setStatus("confirmed");
		// Update vào database
		newEventBO.updateEvent(eventDetail);

		return "Success";

	}

	// Lay tat ca event cua account dang login
	public String getAllEvent() {
		Account account = (Account) sessionMap.get("USER_INFO");

		EventBO newEventBO = new EventBO();
		List<Event> list = newEventBO.getAllEvent(account);

		EventcategoryBO newCatBO = new EventcategoryBO();
		List<Eventcategory> catList = newCatBO.getAllEventCategory(false);

		// Lay cac Event co trong ngay hien tai
		// Tao 1 list event moi
		/*
		 * List<Event> eventInDay = new ArrayList<Event>(); for (int i = 0; i< list.size(); i++){
		 * Event event = list.get(i);
		 * 
		 * String timeTemp = event.getStartTime(); if(timeTemp.equals("2014-02-12")){
		 * eventInDay.add(list.get(i)); } //event
		 * .setStartTime(EpcsDateTimeUtil.convertToJSPDatetime(event.getStartTime ()));
		 * //event.setEndTime(EpcsDateTimeUtil.convertToJSPDatetime(event.getEndTime ())); }
		 */
		// request.setAttribute("EVENT_IN_DAY_LIST", eventInDay);

		// -----------Lấy các event đang diễn ra--------------//
		// ---------------------------------------------------//
		// Lấy thời gian hiện tại
		DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
		java.util.Date date = new java.util.Date();
		// Chuyển ngày hiện tại ra long
		long currentMoment = date.getTime();
		//System.out.println("gio hien tai 1: " + currentMoment);

		// Bắt đầu so sánh ngày h start và end của event, nếu đang diễn ra thì bỏ vào 1 list
		/**
		 * working_event_list = list sự kiện đang diễn ra 
		 * end_event_list =  list sự kiện đã kết thúc
		 * future_event_list = list sự kiện sắp diễn ra
		 * follow_event_list  = list sự kiện họ đã follow và chưa kết thúc
		 */
		List<Event> working_event_list = new ArrayList<Event>();
		List<Event> end_event_list = new ArrayList<Event>();
		List<Event> future_event_list = new ArrayList<Event>();
		List<Event> follow_event_list = new ArrayList<Event>();
		for (int i = 0; i < list.size(); i++) {
			Event event = list.get(i);
		
			long longStart = EpcsDateTimeUtil.getMillisecondsByString(event.getStartTime());
			long longEnd = EpcsDateTimeUtil.getMillisecondsByString(event.getEndTime());

			boolean needToCheckAllDayEvent = true;
			if (longStart < currentMoment && currentMoment < longEnd) {
				// Lấy thời gian cho tới khi sự kiện kết thúc
				long avaibleTime = longEnd - currentMoment;
				long daysAvailable = avaibleTime / (24 * 60 * 60 * 1000);
				long hoursAvailable = avaibleTime / (60 * 60 * 1000) % 24;
				long minsAvailable = avaibleTime / (60 * 1000) % 60;
				// Đăng sửa cho anh Trung --> xét nếu 0 ngày thì thôi khỏi show
				String timeAvailable = new String();
				if (daysAvailable > 0){
					timeAvailable = (daysAvailable + " ngày, " + hoursAvailable + " giờ, " + minsAvailable + " phút.");
				} else {
					timeAvailable = (hoursAvailable + " giờ, " + minsAvailable + " phút.");
				}
				 
				event.setEndTime(timeAvailable);
				working_event_list.add(event);
				
				// vì lý do an toàn: Event đang working sẽ kko cần kiểm tra endTime để tránh parse error
				// Vì: event.setEndTime(timeAvailable); sẽ gán chuỗi ko thể nào parse sang datetime dc
				// đó là lý do có tồn tại biến needToCheckAllDayEvent
				needToCheckAllDayEvent = false;
				
			} else if (currentMoment > longEnd) {
				end_event_list.add(event);
			} else if (currentMoment < longStart) {
				future_event_list.add(event);
			}
			
			if(event.getOrganizer() != null && currentMoment < longStart ){
				follow_event_list.add(event);
			}
			
			//-----------------Đăng-----------------//
			// lấy thời gian kết thúc chính xác cho sự kiện all day
			if (event.getIsAllDayEvent() && needToCheckAllDayEvent){
				String endTime = EpcsDateTimeUtil.getPreviousDayISO(event.getEndTime());
				event.setEndTime(EpcsDateTimeUtil.convertToJSPDatetime(endTime));
			}
		}

		request.setAttribute("WORKING_EVENT_LIST", working_event_list);
		request.setAttribute("END_EVENT_LIST", end_event_list);
		request.setAttribute("FUTURE_EVENT_LIST", future_event_list);
		request.setAttribute("FOLLOW_EVENT_LIST", follow_event_list);
		request.setAttribute("EVENT_LIST", list);
		request.setAttribute("CATEGORY_LIST", catList);

		return "Success";
	}

	public String getEventAtManagePage() {
		Account account = (Account) sessionMap.get("USER_INFO");

		EventBO newEventBO = new EventBO();
		List<Event> list = newEventBO.getAllEvent(account);

		EventcategoryBO newCatBO = new EventcategoryBO();

		// Lay cac Event co trong ngay hien tai
		// Tao 1 list event moi
		/*
		 * List<Event> eventInDay = new ArrayList<Event>(); for (int i = 0; i< list.size(); i++){
		 * Event event = list.get(i);
		 * 
		 * String timeTemp = event.getStartTime(); if(timeTemp.equals("2014-02-12")){
		 * eventInDay.add(list.get(i)); } //event
		 * .setStartTime(EpcsDateTimeUtil.convertToJSPDatetime(event.getStartTime ()));
		 * //event.setEndTime(EpcsDateTimeUtil.convertToJSPDatetime(event.getEndTime ())); }
		 */
		// request.setAttribute("EVENT_IN_DAY_LIST", eventInDay);

		// -----------Lấy các event đang diễn ra--------------//
		// ---------------------------------------------------//
		// Lấy thời gian hiện tại
		DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
		java.util.Date date = new java.util.Date();
		// Chuyển ngày hiện tại ra long
		long currentMoment = date.getTime();
		//System.out.println("H hien tai " + date);

		// Bắt đầu so sánh ngày h start và end của event, nếu đang diễn ra thì bỏ vào 1 list
		List<Event> working_event_list = new ArrayList<Event>();
		List<Event> end_event_list = new ArrayList<Event>();
		List<Event> future_event_list = new ArrayList<Event>();
		for (int i = 0; i < list.size(); i++) {
			Event event = list.get(i);
			EpcsDateTimeUtil epcsStart = new EpcsDateTimeUtil();
			long longStart = epcsStart.getMillisecondsByString(event.getStartTime());
			long longEnd = epcsStart.getMillisecondsByString(event.getEndTime());

			if (longStart < currentMoment && currentMoment < longEnd) {
				// Lấy thời gian cho tới khi sự kiện kết thúc
				long avaibleTime = longEnd - currentMoment;
				long daysAvailable = avaibleTime / (24 * 60 * 60 * 1000);
				long hoursAvailable = avaibleTime / (60 * 60 * 1000) % 24;
				long minsAvailable = avaibleTime / (60 * 1000) % 60;
				//System.out.println("Ngay con lai" + avaibleTime);
				String timeAvailable = (daysAvailable + " ngày, " + hoursAvailable + " giờ, " + minsAvailable + " phút.");
				event.setEndTime(timeAvailable);
				
				working_event_list.add(event);
			} else if (currentMoment > longEnd) {
				end_event_list.add(event);
			} else if (currentMoment < longStart  && future_event_list.size() < 7) {
				future_event_list.add(event);
			}
		}

		request.setAttribute("WORKING_EVENT_LIST", working_event_list);
		request.setAttribute("END_EVENT_LIST", end_event_list);
		request.setAttribute("FUTURE_EVENT_LIST", future_event_list);
		request.setAttribute("EVENT_LIST", list);

		return "Success";
	}

	// Lay tat ca Public event
	public String getNewEvents() {
		String result = "Success";
		Account account = (Account) sessionMap.get("USER_INFO");
		EventBO newEventBO = new EventBO();
		FollowingBO followBO = new FollowingBO();

		// Lấy list categoryId mà user quan tâm
		int maxRecord = 10;
		List<Event> list = newEventBO.getNewEvents(1, maxRecord, account);
		if (list != null) {
			if (list.size() > 0) {
				List<Following> listFollowing = new ArrayList<Following>();
				for (int i = 0; i < list.size(); i++) {
					Event event = list.get(i);
					listFollowing.add(followBO.loadFollowing(account, event.getEventId()));
				}
				request.setAttribute("PUBLIC_EVENT_LIST", list);
				request.setAttribute("FOLLOWING_PUBLIC_EVENT_LIST", listFollowing);
			} else {
				request.setAttribute("WARNING_MESSAGE",
						"Không có sự kiện mới nào thuộc các thể loại mà bạn đang theo dõi!<br/>Bạn có thể theo dõi thêm các thể loại được gợi ý bên dưới nhằm giúp hệ thống tìm kiếm cho bạn tốt hơn...");
				request.setAttribute("LOAD_TOP_CATEGORY",true);
				result = "GetCategoryPage";
			}
		} else {
			request.setAttribute("WARNING_MESSAGE", "Bạn chưa theo dõi bất kỳ thể loại nào!<br/>Bạn có thể theo dõi các thể loại được gợi ý bên dưới...");
			request.setAttribute("LOAD_TOP_CATEGORY",true);
			result = "GetCategoryPage";
		}
		/**
		 * Lấy 3 event sắp diễn ra gần nhất của account đang login
		 */
		List<Integer> eventIdList = followBO.getEventIdListByAccount(account);
		List<Event> eventList = newEventBO.getCommingEvent(eventIdList, 0, 3);
		request.setAttribute("COMMING_EVENT_LIST", eventList);
		return result;
	}
	
	// Lay tat ca Public event
	public String getMoreNewEvents() {
		String result = "Success";
		Account account = (Account) sessionMap.get("USER_INFO");
		EventBO newEventBO = new EventBO();
		
		// Lấy list categoryId mà user quan tâm
		int maxRecord = 10;
		List<Event> list = newEventBO.getNewEvents(pageNumber, maxRecord, account);
		
		request.setAttribute("PUBLIC_EVENT_LIST", list);
		
		
		if (list != null) {
			if (list.size() > 0) {
				
				FollowingBO followBO = new FollowingBO();
				List<Following> listFollowing = new ArrayList<Following>();
				for (int i = 0; i < list.size(); i++) {
					Event event = list.get(i);
					listFollowing.add(followBO.loadFollowing(account, event.getEventId()));
				}
				request.setAttribute("FOLLOWING_PUBLIC_EVENT_LIST", listFollowing);
			} else {
				request.setAttribute("EMPTY_LIST", true);
			}
		} else {			
			request.setAttribute("EMPTY_LIST", true);
		}
		return result;
	}

	// Lay event dua vao id truyen vao
	public String getEvent() {
		Account account = (Account) sessionMap.get("USER_INFO");
		// Lay noi dung cua Event
	
		EventBO newEventBO = new EventBO();
		FollowingBO followBO = new FollowingBO();
		Event eventDetail = newEventBO.getEvent(id);
		
		if (account == null) {
			return "Unauthorized";
		}
		
		if(eventDetail!= null){
			// dùng request để biết có phải là chủ sở hữu event k
			if(eventDetail.getOrganizer() == null && account.getUsername().equals(eventDetail.getAccount().getUsername())){
				request.setAttribute("IS_OWNER", "true");
			}
			Following following =  followBO.loadFollowingEvent(account,id);
			// dùng request để biết có phải là sự kiện public k
			if("public".equals(eventDetail.getVisibility()) || account.getUsername().equals(eventDetail.getAccount().getUsername()) || following!=null){
				request.setAttribute("IS_PUBLIC_EVENT", "true");
			}
			//Kiểm tra xem có phải event chính không
			if(eventDetail.getOrganizer() == null){
				request.setAttribute("IS_MAIN_EVENT", "true");
			}
			if("confirmed".equals(eventDetail.getStatus())){
				request.setAttribute("IS_CONFIRM_EVENT", "true");
			}
			
			eventDetail.setStartTime(EpcsDateTimeUtil.convertToJSPDatetime(eventDetail.getStartTime()));
			eventDetail.setEndTime((EpcsDateTimeUtil.convertToJSPDatetime(eventDetail.getEndTime())));

			// Lay commnet
			CommentBO newCommentBO = new CommentBO();
			List<Comment> commentList = newCommentBO.getAllCommentByEventId(eventDetail);
			// Lay event category

			EventcategoryBO newCatBO = new EventcategoryBO();
			List<Eventcategory> catList = newCatBO.getAllEventCategory(true);
			
			if(catList != null) {
				// loại bỏ các category bị de-active (trừ trường hợp category đó là của event hiện tại thì giữ lại)
				for (int i = 0; i < catList.size(); i++){
					Eventcategory item = catList.get(i);
					if (!item.getIsActive()){
						if (item.getEventCategoryId().compareTo(eventDetail.getEventcategory().getEventCategoryId()) != 0){
							catList.remove(i);
							i = i - 1;
						}
					}
				}
			}
			
			
			request.setAttribute("CATEGORY_LIST", catList);
			request.setAttribute("EVENT_DETAIL", eventDetail);
			request.setAttribute("COMMENT_LIST", commentList);
			
			// ----------------------------------------Nhân------------------------------------------------------
			
			Following follow = followBO.loadFollowing(account, Integer.parseInt(id));

			request.setAttribute("FOLLOWING_EVENT", follow);
			// ---------------------------------------------------------------------------------------------------
			
			// ----------------------------------------Đăng------------------------------------------------------		
			request.setAttribute("NUMBER_OF_FOLLOWING", followBO.getNumberOfFollowingByEvent(eventDetail));
			// xét trạng thái hiện tại của event
			long currentTime = EpcsDateTimeUtil.getMillisecondsByString(EpcsDateTimeUtil.getCurrentIsoDateTime());
			long eventStartTime = EpcsDateTimeUtil.getMillisecondsByString(eventDetail.getStartTime());
			long eventStopTime = EpcsDateTimeUtil.getMillisecondsByString(eventDetail.getEndTime());
			
			if (eventStartTime <= currentTime && currentTime <= eventStopTime){
				request.setAttribute("CURRENT_EVENT_STATUS", "Đang diễn ra");
			} else if (currentTime < eventStartTime) {
				request.setAttribute("CURRENT_EVENT_STATUS", "Sắp diễn ra");
			} else {
				request.setAttribute("CURRENT_EVENT_STATUS", "Đã kết thúc");
			}
			// ---------------------------------------------------------------------------------------------------

			return "Success";
		}else{
			return "NotExit";
		}
		
	}

	public String getEventByAjax() {

		//System.out.println("getEventByAjax id =" + id);
		// Lay noi dung cua Event
		try {
			EventBO newEventBO = new EventBO();
			Event eventDetail = newEventBO.getEvent(id);
			request.setAttribute("EVENT_DETAIL", eventDetail);
		} catch (Exception e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}

		return "Success";
	}

	// ------------------------------------DUY-----------------------------------------------------
	public String getAllPublicEventByCategory() {
		EventBO newEventBO = new EventBO();
		FollowingBO followBO = new FollowingBO();
		Account account = (Account) sessionMap.get("USER_INFO");
		Eventcategory categoryItem = new EventcategoryBO().getCategoryByID(categoryID);
		int maxRecord = 10;

		List<Event> eventList = newEventBO.getAllPublicEventByCategory(1, maxRecord, account,categoryItem);
		request.setAttribute("CATEGORY_ITEM", categoryItem);
		if(eventList != null){
			List<Following>listFollowing= followBO.getFollowingListByEventList(eventList, account);
			
			request.setAttribute("PUBLIC_EVENT_CATEGORY_LIST", eventList);
			request.setAttribute("FOLLOWING_PUBLIC_EVENT_LIST", listFollowing);
		}else{
				request.setAttribute("WARNING_MESSAGE","Vẫn chưa có bất kỳ sự kiện nào thuộc thể loại "+ categoryItem.getEventCategoryName());
		}
		return "Success";
	}
	public String getMorePublicEventByCategory() {
		EventBO newEventBO = new EventBO();
		FollowingBO followBO = new FollowingBO();
		Account account = (Account) sessionMap.get("USER_INFO");
		Eventcategory categoryItem = new EventcategoryBO().getCategoryByID(categoryID);
		int maxRecord = 10;
		
		List<Event> eventList = newEventBO.getAllPublicEventByCategory(pageNumber, maxRecord, account,categoryItem);
		request.setAttribute("CATEGORY_ITEM", categoryItem);
		if(eventList != null){
			if(eventList.size()>0){
				List<Following>listFollowing= followBO.getFollowingListByEventList(eventList, account);
				
				request.setAttribute("PUBLIC_EVENT_CATEGORY_LIST", eventList);
				request.setAttribute("FOLLOWING_PUBLIC_EVENT_LIST", listFollowing);
				
			} else {
				request.setAttribute("EMPTY_LIST", true);
			}
			
		}else{
			request.setAttribute("EMPTY_LIST", true);
		}
		return "Success";
	}

	public String getEventByNotification() {
		EventBO newEventBO = new EventBO();
		Event eventDetail = newEventBO.getEvent(id);
		FollowingBO followBO = new FollowingBO();
		Account account = (Account) sessionMap.get("USER_INFO");
		if(eventDetail!= null){
			// dùng request để biết có phải là chủ sở hữu event k
			if(eventDetail.getOrganizer() == null && eventDetail.getAccount().getUsername().equals(account.getUsername())){
				request.setAttribute("IS_OWNER", "true");
			}
			Following following =  followBO.loadFollowingEvent(account,id);
			// dùng request để biết có phải là sự kiện public k
			if("public".equals(eventDetail.getVisibility()) || account.getUsername().equals(eventDetail.getAccount().getUsername()) || following!=null){
				request.setAttribute("IS_PUBLIC_EVENT", "true");
			}
			//Kiểm tra xem có phải event chính không
			if(eventDetail.getOrganizer() == null){
				request.setAttribute("IS_MAIN_EVENT", "true");
			}
			//Kiểm tra xem có phải event đã cancel hay chưa	
			if("confirmed".equals(eventDetail.getStatus())){
				request.setAttribute("IS_CONFIRM_EVENT", "true");
			}
			// Lấy Notification rồi chuyokển status thành đã đọc (2)
			NotificationBO notifyBO = new NotificationBO();
			Notification notification = notifyBO.getNotificationByNotificationID(Integer.parseInt(notificationId));
			if(notification!=null){
				notification.setStatus(2);
				notifyBO.updateNotificationComment(notification);
			}
		

			// Lay noi dung cua Event
		
		
			eventDetail.setStartTime(EpcsDateTimeUtil.convertToJSPDatetime(eventDetail.getStartTime()));
			eventDetail.setEndTime((EpcsDateTimeUtil.convertToJSPDatetime(eventDetail.getEndTime())));

			// Lay commnet
			CommentBO newCommentBO = new CommentBO();
			List<Comment> commentList = newCommentBO.getAllCommentByEventId(eventDetail);
			
			request.setAttribute("EVENT_DETAIL", eventDetail);
			request.setAttribute("COMMENT_LIST", commentList);

			// ----------------------------------------Nhân------------------------------------------------------
		

			Following follow = followBO.loadFollowing(account, Integer.parseInt(id));

			request.setAttribute("FOLLOWING_EVENT", follow);
			request.setAttribute("NUMBER_OF_FOLLOWING", followBO.getNumberOfFollowingByEvent(eventDetail));
			// ---------------------------------------------------------------------------------------------------

			
			// ------------------------------------Đăng-----------------------------------------------------
			// xét trạng thái hiện tại của event
			long currentTime = EpcsDateTimeUtil.getMillisecondsByString(EpcsDateTimeUtil.getCurrentIsoDateTime());
			long eventStartTime = EpcsDateTimeUtil.getMillisecondsByString(eventDetail.getStartTime());
			long eventStopTime = EpcsDateTimeUtil.getMillisecondsByString(eventDetail.getEndTime());
			
			if (eventStartTime <= currentTime && currentTime <= eventStopTime){
				request.setAttribute("CURRENT_EVENT_STATUS", "Đang diễn ra");
			} else if (currentTime < eventStartTime) {
				request.setAttribute("CURRENT_EVENT_STATUS", "Sắp diễn ra");
			} else {
				request.setAttribute("CURRENT_EVENT_STATUS", "Đã kết thúc");
			}
			// ---------------------------------------------------------------------------------------------------
			

			return "Success";
		}else{
			return "NotExit";
		}
	}

	// --------------------------------------------------------------------------------------------
	// -----------Getter and Setter -----//

	public String getTitle() {
		return title;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String[] getInvitedPersonArr() {
		return invitedPersonArr;
	}

	public void setInvitedPersonArr(String[] invitedPersonArr) {
		this.invitedPersonArr = invitedPersonArr;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public String getIsAllDay() {
		return isAllDay;
	}

	public void setIsAllDay(String isAllDay) {
		this.isAllDay = isAllDay;
	}

	public String getDaterange_start() {
		return daterange_start;
	}

	public void setDaterange_start(String daterange_start) {
		this.daterange_start = daterange_start;
	}

	public String getDaterange_end() {
		return daterange_end;
	}

	public void setDaterange_end(String daterange_end) {
		this.daterange_end = daterange_end;
	}

	public Integer getEventCat() {
		return eventCat;
	}

	public void setEventCat(Integer eventCat) {
		this.eventCat = eventCat;
	}

	public String getLocation() {
		return location;
	}

	public void setLocation(String location) {
		this.location = location;
	}

	public String getDescription() {
		return description;
	}

	public void setDescription(String description) {
		this.description = description;
	}

	public String getInvitedPerson() {
		return invitedPerson;
	}

	public String getInvitedUsername() {
		return invitedUsername;
	}

	public void setInvitedUsername(String invitedUsername) {
		this.invitedUsername = invitedUsername;
	}

	public void setInvitedPerson(String invitedPerson) {
		this.invitedPerson = invitedPerson;
	}

	public String getVisibility() {
		return visibility;
	}

	public void setVisibility(String visibility) {
		this.visibility = visibility;
	}

	public Integer getReminder() {
		return reminder;
	}

	public void setReminder(Integer reminder) {
		this.reminder = reminder;
	}

	public String getCategoryID() {
		return categoryID;
	}

	public void setCategoryID(String categoryID) {
		this.categoryID = categoryID;
	}

	public String getNotificationId() {
		return notificationId;
	}

	public void setNotificationId(String notificationId) {
		this.notificationId = notificationId;
	}

	public int getPageNumber() {
		return pageNumber;
	}

	public void setPageNumber(int pageNumber) {
		this.pageNumber = pageNumber;
	}
	public String getReminder_now() {
		return reminder_now;
	}

	public void setReminder_now(String reminder_now) {
		this.reminder_now = reminder_now;
	}

	// ---------------- session --------------------//

	@Override
	public void setSession(Map<String, Object> sessionMap) {
		this.sessionMap = (SessionMap<String, Object>) sessionMap;
	}

	@Override
	public void setServletRequest(HttpServletRequest request) {
		this.request = request;

	}

}
